package storage

import (
	"context"
	"fmt"
	"log"
	"sync"
	"time"
)

// StorageManager 存储管理器
type StorageManager struct {
	client      VectorStorage
	config      *StorageConfig
	collections map[string]*CollectionManager
	mutex       sync.RWMutex
	initialized bool
}

// CollectionManager 集合管理器
type CollectionManager struct {
	name       string
	config     *CollectionConfig
	lastAccess time.Time
	mutex      sync.RWMutex
}

// NewStorageManager 创建存储管理器
func NewStorageManager() *StorageManager {
	return &StorageManager{
		collections: make(map[string]*CollectionManager),
	}
}

// Initialize 初始化存储管理器
func (sm *StorageManager) Initialize(config *StorageConfig) error {
	sm.mutex.Lock()
	defer sm.mutex.Unlock()

	if sm.initialized {
		return fmt.Errorf("存储管理器已初始化")
	}

	log.Println("正在初始化存储管理器...")

	sm.config = config

	// 创建简化的存储客户端实现
	client := NewSimpleStorageClient()

	// 初始化客户端
	if err := client.Initialize(config); err != nil {
		return fmt.Errorf("初始化存储客户端失败: %w", err)
	}

	sm.client = client

	// 加载现有集合
	if err := sm.loadExistingCollections(); err != nil {
		log.Printf("加载现有集合失败: %v", err)
	}

	sm.initialized = true
	log.Println("存储管理器初始化完成")

	return nil
}

// Close 关闭存储管理器
func (sm *StorageManager) Close() error {
	sm.mutex.Lock()
	defer sm.mutex.Unlock()

	if !sm.initialized {
		return nil
	}

	log.Println("正在关闭存储管理器...")

	if sm.client != nil {
		if err := sm.client.Close(); err != nil {
			return fmt.Errorf("关闭存储客户端失败: %w", err)
		}
	}

	sm.initialized = false
	log.Println("存储管理器已关闭")

	return nil
}

// IsReady 检查是否就绪
func (sm *StorageManager) IsReady() bool {
	sm.mutex.RLock()
	defer sm.mutex.RUnlock()

	return sm.initialized && sm.client != nil && sm.client.IsReady()
}

// CreateCollection 创建集合
func (sm *StorageManager) CreateCollection(name string, config *CollectionConfig) error {
	sm.mutex.Lock()
	defer sm.mutex.Unlock()

	if !sm.initialized {
		return fmt.Errorf("存储管理器未初始化")
	}

	// 检查集合是否已存在
	if _, exists := sm.collections[name]; exists {
		return fmt.Errorf("集合 %s 已存在", name)
	}

	log.Printf("正在创建集合: %s", name)

	// 创建集合
	ctx := context.Background()
	if err := sm.client.CreateCollection(ctx, name, config); err != nil {
		return fmt.Errorf("创建集合失败: %w", err)
	}

	// 创建集合管理器
	collectionManager := &CollectionManager{
		name:       name,
		config:     config,
		lastAccess: time.Now(),
	}

	sm.collections[name] = collectionManager

	log.Printf("集合 %s 创建成功", name)
	return nil
}

// DeleteCollection 删除集合
func (sm *StorageManager) DeleteCollection(name string) error {
	sm.mutex.Lock()
	defer sm.mutex.Unlock()

	if !sm.initialized {
		return fmt.Errorf("存储管理器未初始化")
	}

	// 检查集合是否存在
	if _, exists := sm.collections[name]; !exists {
		return fmt.Errorf("集合 %s 不存在", name)
	}

	log.Printf("正在删除集合: %s", name)

	// 删除集合
	ctx := context.Background()
	if err := sm.client.DeleteCollection(ctx, name); err != nil {
		return fmt.Errorf("删除集合失败: %w", err)
	}

	// 删除集合管理器
	delete(sm.collections, name)

	log.Printf("集合 %s 删除成功", name)
	return nil
}

// GetCollection 获取集合管理器
func (sm *StorageManager) GetCollection(name string) (*CollectionManager, error) {
	sm.mutex.RLock()
	defer sm.mutex.RUnlock()

	if !sm.initialized {
		return nil, fmt.Errorf("存储管理器未初始化")
	}

	collectionManager, exists := sm.collections[name]
	if !exists {
		return nil, fmt.Errorf("集合 %s 不存在", name)
	}

	// 更新访问时间
	collectionManager.mutex.Lock()
	collectionManager.lastAccess = time.Now()
	collectionManager.mutex.Unlock()

	return collectionManager, nil
}

// ListCollections 列出所有集合
func (sm *StorageManager) ListCollections() ([]string, error) {
	sm.mutex.RLock()
	defer sm.mutex.RUnlock()

	if !sm.initialized {
		return nil, fmt.Errorf("存储管理器未初始化")
	}

	collections := make([]string, 0, len(sm.collections))
	for name := range sm.collections {
		collections = append(collections, name)
	}

	return collections, nil
}

// InsertVectors 插入向量
func (sm *StorageManager) InsertVectors(collection string, vectors []*VectorData) error {
	if !sm.initialized {
		return fmt.Errorf("存储管理器未初始化")
	}

	// 检查集合是否存在
	if _, err := sm.GetCollection(collection); err != nil {
		return err
	}

	ctx := context.Background()
	return sm.client.InsertVectors(ctx, collection, vectors)
}

// SearchVectors 搜索向量
func (sm *StorageManager) SearchVectors(collection string, query *SearchQuery) (*SearchResult, error) {
	if !sm.initialized {
		return nil, fmt.Errorf("存储管理器未初始化")
	}

	// 检查集合是否存在
	if _, err := sm.GetCollection(collection); err != nil {
		return nil, err
	}

	ctx := context.Background()
	return sm.client.SearchVectors(ctx, collection, query)
}

// UpdateVector 更新向量
func (sm *StorageManager) UpdateVector(collection string, id string, vector *VectorData) error {
	if !sm.initialized {
		return fmt.Errorf("存储管理器未初始化")
	}

	// 检查集合是否存在
	if _, err := sm.GetCollection(collection); err != nil {
		return err
	}

	ctx := context.Background()
	return sm.client.UpdateVector(ctx, collection, id, vector)
}

// DeleteVectors 删除向量
func (sm *StorageManager) DeleteVectors(collection string, ids []string) error {
	if !sm.initialized {
		return fmt.Errorf("存储管理器未初始化")
	}

	// 检查集合是否存在
	if _, err := sm.GetCollection(collection); err != nil {
		return err
	}

	ctx := context.Background()
	return sm.client.DeleteVectors(ctx, collection, ids)
}

// GetStorageStats 获取存储统计
func (sm *StorageManager) GetStorageStats() (*StorageStats, error) {
	if !sm.initialized {
		return nil, fmt.Errorf("存储管理器未初始化")
	}

	ctx := context.Background()
	return sm.client.GetStorageStats(ctx)
}

// GetCollectionInfo 获取集合信息
func (sm *StorageManager) GetCollectionInfo(collection string) (*CollectionInfo, error) {
	if !sm.initialized {
		return nil, fmt.Errorf("存储管理器未初始化")
	}

	// 检查集合是否存在
	if _, err := sm.GetCollection(collection); err != nil {
		return nil, err
	}

	ctx := context.Background()
	return sm.client.GetCollectionInfo(ctx, collection)
}

// OptimizeCollection 优化集合
func (sm *StorageManager) OptimizeCollection(collection string) error {
	if !sm.initialized {
		return fmt.Errorf("存储管理器未初始化")
	}

	// 检查集合是否存在
	if _, err := sm.GetCollection(collection); err != nil {
		return err
	}

	ctx := context.Background()
	return sm.client.OptimizeIndex(ctx, collection)
}

// BatchInsert 批量插入
func (sm *StorageManager) BatchInsert(collection string, vectors []*VectorData) (*BatchResult, error) {
	if !sm.initialized {
		return nil, fmt.Errorf("存储管理器未初始化")
	}

	// 检查集合是否存在
	if _, err := sm.GetCollection(collection); err != nil {
		return nil, err
	}

	ctx := context.Background()
	batchSize := sm.config.BatchSize
	return sm.client.BatchInsert(ctx, collection, vectors, batchSize)
}

// BatchDelete 批量删除
func (sm *StorageManager) BatchDelete(collection string, ids []string) (*BatchResult, error) {
	if !sm.initialized {
		return nil, fmt.Errorf("存储管理器未初始化")
	}

	// 检查集合是否存在
	if _, err := sm.GetCollection(collection); err != nil {
		return nil, err
	}

	ctx := context.Background()
	batchSize := sm.config.BatchSize
	return sm.client.BatchDelete(ctx, collection, ids, batchSize)
}

// CreateIndex 创建索引
func (sm *StorageManager) CreateIndex(collection string, config *IndexConfig) error {
	if !sm.initialized {
		return fmt.Errorf("存储管理器未初始化")
	}

	// 检查集合是否存在
	if _, err := sm.GetCollection(collection); err != nil {
		return err
	}

	ctx := context.Background()
	return sm.client.CreateIndex(ctx, collection, config)
}

// GetIndexInfo 获取索引信息
func (sm *StorageManager) GetIndexInfo(collection string) ([]*IndexInfo, error) {
	if !sm.initialized {
		return nil, fmt.Errorf("存储管理器未初始化")
	}

	// 检查集合是否存在
	if _, err := sm.GetCollection(collection); err != nil {
		return nil, err
	}

	ctx := context.Background()
	return sm.client.GetIndexInfo(ctx, collection)
}

// HealthCheck 健康检查
func (sm *StorageManager) HealthCheck() error {
	sm.mutex.RLock()
	defer sm.mutex.RUnlock()

	if !sm.initialized {
		return fmt.Errorf("存储管理器未初始化")
	}

	if sm.client == nil {
		return fmt.Errorf("存储客户端未初始化")
	}

	return sm.client.HealthCheck()
}

// GetClient 获取存储客户端
func (sm *StorageManager) GetClient() VectorStorage {
	sm.mutex.RLock()
	defer sm.mutex.RUnlock()

	return sm.client
}

// 辅助方法

// loadExistingCollections 加载现有集合
func (sm *StorageManager) loadExistingCollections() error {
	ctx := context.Background()
	collections, err := sm.client.ListCollections(ctx)
	if err != nil {
		return err
	}

	for _, name := range collections {
		info, err := sm.client.GetCollectionInfo(ctx, name)
		if err != nil {
			log.Printf("获取集合 %s 信息失败: %v", name, err)
			continue
		}

		collectionManager := &CollectionManager{
			name:       name,
			config:     info.Config,
			lastAccess: time.Now(),
		}

		sm.collections[name] = collectionManager
		log.Printf("加载集合: %s", name)
	}

	return nil
}

// CollectionManager 方法

// GetName 获取集合名称
func (cm *CollectionManager) GetName() string {
	cm.mutex.RLock()
	defer cm.mutex.RUnlock()

	return cm.name
}

// GetConfig 获取集合配置
func (cm *CollectionManager) GetConfig() *CollectionConfig {
	cm.mutex.RLock()
	defer cm.mutex.RUnlock()

	return cm.config
}

// GetLastAccess 获取最后访问时间
func (cm *CollectionManager) GetLastAccess() time.Time {
	cm.mutex.RLock()
	defer cm.mutex.RUnlock()

	return cm.lastAccess
}

// UpdateAccess 更新访问时间
func (cm *CollectionManager) UpdateAccess() {
	cm.mutex.Lock()
	defer cm.mutex.Unlock()

	cm.lastAccess = time.Now()
}
